The 640 MEG Shareware Studio 2/The 640 Meg Shareware Studio CD-ROM Volume II (Data Express)(1993).ISO/windows/fullv.zip/FULLVIEW.DOC

Text File | 1992-02-09 | 38KB | 814 lines

                ********************************
                *           FULLVIEW           *
                *              5.0             *
                *                              *
                *              by              *
                *                              *
                *       Patrick A. Toulme      *
                *  Copyright -  January, 1992  *
                *        Patents Pending       *
                *      All Rights Reserved     *
                ********************************


================================================================

THIS IS A FULLY FUNCTIONAL DEMONSTRATION COPY OF THE FULLVIEW
UTILITY -- IT FUNCTIONS IDENTICALLY TO THE LICENSED VERSION OF
FULLVIEW WITH THE FOLLOWING EXCEPTIONS:

1)  FILE WRITES WILL ALWAYS BE 64 BYTES LONG.
2)  YOU MAY NOT PERFORM "NEXT SEARCHES" AND YOU
    MAY NOT IMPLODE CONTROL.
3)  SOME AREAS OF CONVENTIONAL MEMORY ARE TEMPORARILY PREVENTED
    FROM BEING VIEWED, SOME AREAS OF EXTENDED MEMORY ARE ALWAYS
    PREVENTED FROM BEING VIEWED.
================================================================



I.   INTRODUCTION.


    FULLVIEW has been designed to aid both the novice user,
through the experienced "power user," all the way up to the
software-code writer and the computer hardware technician.
FULLVIEW has the ability to perform functions that, until now,
were only possible with expensive hardware-based products and
custom memory software.  And truthfully, FULLVIEW is easier to
use and performs more useable functions.  In fact, the more I
work with FULLVIEW, the more possibilities I see for its use.  I
now look at FULLVIEW as an indispensable utility for working with
DOS and Windows based personal computers.  I'm sure you will see
as many uses for FULLVIEW as I do as you implement it, and work
with it, in your own fashion.



II.  WHAT IS FULLVIEW?

    FULLVIEW is a ticket to the entire memory structure of the
personal computer.  FULLVIEW outperforms any currently available
memory viewing utility in that it will allow you to actually see,
change, search, and work with all of your memory --all the way up
to 16 megabytes of RAM.  You can actually view the contents of
conventional RAM, expanded memory page frames, ROM, and even
extended memory -- all in REAL TIME and all at the touch of a
key.  FULLVIEW is the perfect complement to any user, programmer,
or developer's utility/memory/debugging software.

    FULLVIEW is a well-behaved TSR, just about 20k in size, and
has been written completely in assembly language for speed, and,
after installation, uses NO DOS CALLS (actually, it uses one, one
time) and only direct low-level BIOS calls.  This fact is of
critical importance since it allows the user to "hotkey" into
FULLVIEW at any time -- even while another program is in the
middle of loading, printing, executing, changing memory,
executing Read-Only-Memory, writing to the screen, writing to a
disk, or being manipulated by a debugger (FULLVIEW is compatible
with all major debuggers -- even those that operate in Virtual-86
mode), or most anything else a program can do. . . including
decompress, de-copy protect, and decrypt itself.  And what's
more, when you exit from FULLVIEW, the program that you
interrupted will continue with its execution without missing a
beat -- in fact, it will never even know that it has been
interrupted.

    Another advantage of FULLVIEW's use of pure machine language
is that FULLVIEW takes all its information directly from the
registers, the stack, and direct memory reads of your system --
FULLVIEW is not fooled by malfunctioning (or intentionally
deceptive) interrupt handlers.  What you see with FULLVIEW is
what's actually there.



III.  INSTALLATION.

    FULLVIEW is fully compatible with DOS Version 5.0 and may be
loaded "high" above 640k in the Upper Memory Blocks (UMBs) of a
386-based machine.  When FULLVIEW is loaded high (by using the
DOS command LH, the user will be able to view it in two places:
1)  The re-mapped location above the 640k barrier (say, at
segment D132, for instance); and 2) The "true" location in
extended memory.  Of course, FULLVIEW allows you to observe both
locations, as the code changes, in real time.  FULLVIEW is also
fully compatible with Windows 3.0 and may be loaded and run in
multiple windows (included on this disk are two Windows related
files, WIN-FVW.BAT and WIN-FVW.PIF -- the batch file is set up
for color installation, if you have a monochrome monitor you
should change the /C to a /M).
    FULLVIEW prefers to be the first TSR that is loaded, but
this is not mandatory for FULLVIEW's effectiveness.  When
FULLVIEW is installed, it modifies its own code to work best with
your system's BIOS, memory, and hardware.  In addition, FULLVIEW
performs a brief self-integrity check.  The only user defined
input that FULLVIEW requires is a command line parameter telling
FULLVIEW whether your system has a color graphics video card
(CGA,EGA,VGA,MCGA), or a monochrome video card
(MDA,Hercules,Mono-VGA/EGA).  FULLVIEW uses this information to
place characters directly into video memory, thus bypassing DOS
and the BIOS.  Screen output is virtually instantaneous -- you
would settle for nothing less, since FULLVIEW updates itself
constantly in real time.  Put another way, you can actually see
your memory changing as it's changing -- right before your eyes.
And it continues to do this regardless of whether it's above or
below the DOS 1 megabyte barrier.  Programming real-time viewing
of extended memory from a TSR is a logistical nightmare
(especially in Virtual-86 mode!), but the results are worth it.
In fact, once you work with FULLVIEW you won't be able to work
again without it.

A Caveat:  If you have one of the old, original IBM-CGA
cards, you might experience "chromablizzard," which
occurs due to trace intervals.  If you see "snow"
across your screen while displaying FULLVIEW, don't
blame FULLVIEW, blame your card, then buy a better one
for about $20.

The syntax for installation for a color card is:
                      FULLVIEW /C

The syntax for installation for a monochrome card is:
                      FULLVIEW /M

    FULLVIEW will advise you if it has been installed correctly,
or, if no parameter is entered, it will display a short screen
reminding you to include a /C or /M.



IV.  ACCESSING AND EXITING FULLVIEW.

    Once FULLVIEW has been installed, you may "hotkey" into it
AT ANY TIME by hitting Control-V.  A note of caution, if you
attempt to access FULLVIEW, which operates in text mode, from an
application program that is operating in graphics mode, you will
hear a short tone and FULLVIEW will not appear.  This does not
mean that you can not access FULLVIEW from a graphics program, it
just means you will either have to "Implode Control," which will
be described later, or, simply hold the Right-Shift key down as
you hotkey.  Doing this will override the present graphics mode
and allow you to enter FULLVIEW.  However, the screen graphics
will not be saved.  But, as a rule, this is not of significant
importance since most graphics programs tend to update the screen
graphics quite frequently.

    To exit FULLVIEW, and return to the executing program,
simply hit Escape.

    Once FULLVIEW is activated, the screen will be filled with
three separate areas:  The Address Area; The Hexadecimal Memory
Area; and The Ascii Memory Area.  All are being updated several
times a second, as you view them.  At the bottom of the screen is
a list of FULLVIEW's most commonly used commands.



V.  WORKING WITH FULLVIEW.

     There are fourteen memory scrolling functions that will
allow you to walk through your conventional, video, ROM-BIOS
memory, expanded memory page frame, and even extended memory, or
jump to a specific point in any of that memory.  The commands are
as follows:

Up Arrow ------- Move 16 bytes (a paragraph) toward low memory.
Down Arrow ----- Move 16 bytes (a paragraph) toward upper memory.
Left Arrow ----- Move 1 byte toward low memory.
Right Arrow ---- Move 1 byte toward upper memory.
Page Up -------- Move one screen-full toward low memory.
Page Down ------ Move one screen-full toward high memory.
Home ----------- Jump to 0000:0000 (the beginning of the Megabyte
                 that you are viewing).  Successive taps on the
                 HOME key will advance you back through the
                 Megabytes one at a time.
End ------------ Jump to F000:FEB0 (the end of the Megabyte that
                 you are viewing).  Successive taps on the END
                 key will advance you up through the Megabytes
                 one at a time.
J -------------- Jump to a user-defined, specific hexadecimal
                 segment:offset in the currently viewed
                 megabyte (a FAR jump to programmers).
X -------------- Jump to an entirely different megabyte in
                 memory (you couldn't even do this, until now).
Ctrl+Page Up --- Move to the beginning of the currently viewed
                 segment; after that, move toward low memory
                 in 64k chunks at a time.
Ctrl+Page Down - Move to the end of the currently viewed
                 segment; after that, move toward high memory
                 in 64k chunks at a time.
Ctrl+Home ------ Jump to the lowest point in memory (0000:0000
                 in conventional memory.)
Ctrl+End ------- Jump to the highest point in memory (the end of
                 what would be the 15th extended memory meg - you
                 probably don't have that much memory installed).



    As you scroll through, or jump through, memory, the actual
hexadecimal bytes, and the ascii representation of that memory,
will change accordingly.  In addition, as you scroll, the
individual byte addresses at the top of the screen and the
segment:offset addresses to the left of the screen will also
change.  This allows the user to easily obtain an accurate
address for the point of memory he is observing.  In addition,
the far left side of the screen displays a vertical bar with a
moving arrow that  represents the position in the total memory
structure that is currently being viewed.  The full-white portion
of the bar represents conventional memory, the lighter-white
portion represents the extended memory that is installed on the
machine, and the large "dots" represent empty memory areas in the
full 16 megabyte spectrum.  If you scroll through the end of a
Megabyte, you will not "wrap-around" to the beginning of that
same Megabyte, but instead will continue on into the next
corresponding Megabyte in a true linear fashion (unless you have
8088-based hardware, then wrapping around will occur, since there
is no possibility of extended memory).  The heading "CONVENT'L"
(meaning you are in conventional memory under 1 Megabyte) will
then change to indicate the extended memory megabyte that you are
now viewing.  Of course, the hexadecimal values and ascii values
are being updated to the screen constantly, regardless of whether
the user is scrolling or not.  And if you're wondering how your
viewing actual, live, and constantly changing extended memory,
while in real mode, it's because FULLVIEW is flying you in and
out of a protected mode environment several times a second -- all
behind the scenes of course, and all without disturbing the
integrity of the program that it interrupted.



VI.  OPERATIONAL COMMANDS.

There are eight operational commands that are displayed at the
bottom of the FULLVIEW main screen; each one will be described in
a bit more detail.  All of these commands work the same way,
regardless of whether you are viewing conventional memory or
extended memory.  And, as a rule, hitting the escape key, as
opposed to providing a correct numerical input, will generally
cancel any operation and return you up through the screens to the
FULLVIEW main screen.  Entering "RETURN" in response to a "Yes or
No?" is interpreted as a "No."  If FULLVIEW is requesting that
you enter a segment and offset address, you may hit the space-bar
to automatically input the currently viewed segment:offset (this
function is not available on Jump requests, however).


    The common operational commands are:


(S) Memory Search ----  for searching memory.
(N) Next Search ------  for searching memory again.
(M) Change Memory ----  for writing directly into memory.
(F) Write to File ----  for writing memory to a disk file.
(I) Ints and Ports ---  for working with interrupts and ports.
(R) Return Address ---  reports the exact point of return.
(P) Prepare Prtscr ---  for stripping control characters.
(C) Crash to DOS -----  for exiting a program, the hard way.


Search Memory:

    This commands allows you to search the currently viewed
megabyte for a hexadecimal or case-sensitive text string up to 30
characters long.  Simply hit "S" and respond to the hex or text
prompt, and then enter your string.  When you hit return, memory
will be searched, starting at the point in memory that the user
is presently viewing, and any matching string will be displayed
by FULLVIEW.  To find the next occurrence of the same string, use
NEXT SEARCH.  If you are searching conventional memory, and
FULLVIEW determines that the High Memory Area is accessible to
DOS (meaning the A20 Gate is open), FULLVIEW will also search the
HMA for the search-string.  If found, FULLVIEW will display the
string as addressed by segment value FFFF.

    One point on searches:  FULLVIEW's searching algorithm
relies on the uniqueness of the first byte of the string for its
speed.  Hexadecimal search strings beginning with 00 or FF will
be noticeably slower than other strings since these two bytes are
the most frequently encountered.  Fortunately, the user will
rarely (if ever) need to begin a search string with either of
these two bytes.  But experiment for yourself -- you can always
suspend the search by hitting F1.


Next Search:

    Finds the next occurrence of a string after SEARCH MEMORY
has found the first.  There are no inputs, just hit "N".  Like
the SEARCH function, searching begins at the point in memory that
is being viewed.  If there are no more occurrences of the string
within that megabyte, a double-tone will sound and the user will
be advised that the string has not been found.


Change Memory:

    This command allows you to write directly into memory at
whatever Megabyte you are currently viewing, and of course,
observe it being updated in real time as you enter it.  When you
hit "M" you will be prompted for a segment:offset in which the
memory will be entered (the space bar will enter the currently
viewed segment and offset for you) - you will then be asked
whether the input will be in hexadecimal or text format.  After
this, you simply begin inputting either the text or hex values
that you would like placed in memory - just hit RETURN when
you're through.  If FULLVIEW is displaying the same memory
location that you are changing, you will see the updates "on the
fly" as they are inserted into RAM.  If you feel like writing
directly into video memory, you will see the image displayed on
your screen for an instant, and then the FULLVIEW display screen
will re-appear -- FULLVIEW takes priority over most everything,
including direct video memory screen writes.


Write to File:

    This command allows you to write a portion of memory to a
disk file.  Upon hitting "F" you will be asked to input three
variables:  The segment, offset, and length of the memory that
you would like written to disk.  Once again, the space bar will
input the currently viewed segment:offset address for you, and
for the length, you may use the cursor keys to scroll through
memory as opposed to actually typing in the length of the file
write (FULLVIEW displays the length of the write as you scroll).
After this, you will be asked to provide the filename that
FULLVIEW will use when it creates and writes the file.  If the
file you name is already in existence, FULLVIEW will write to the
end of that file.  Here is the only time that FULLVIEW uses DOS
-- and, of course, there is always the chance of a DOS-memory
related problem when using DOS from a behind-the-scenes TSR like
FULLVIEW.  If FULLVIEW determines that DOS is unstable, it will
alert the user with a tone and message and then give the user the
option of "forcing" the DOS disk write (which usually works, and
is quite safe).  However, returning to a DOS executing program
after forcing a DOS disk write is a matter of luck.  But, even if
DOS does hang you after trying to return, you should still have
the disk file intact.  Should any other problems come up during
the disk write, FULLVIEW will let you know, and, if the file
write is successful, FULLVIEW will let you know that as well.  An
interesting point -- FULLVIEW, when executing a FileWrite
request, "undercuts" DOS and BIOS.  If you have installed an
interrupt monitoring TSR over FULLVIEW, like the "Write-Protect
Your Hard Disk" programs, FULLVIEW will execute the function
"underneath" the monitoring software, which will, of course, be
unaware of FULLVIEW's operation.


Ints and Ports:

    This command provides the exact segment:offset vector
address for interrupts as they appear in low memory -- not as
they are reported by DOS.  After you hit "I" you will be asked
for the number of the interrupt, FULLVIEW will then report its
address and ask if you would like to change it.  If so, the user
is prompted for a segment:offset address and that address is
inserted into low memory.  If you would like a report on the
entire interrupt vector table, simply hit F1 instead of inputting
an interrupt number.  If you would like the report directed to
the printer instead of the screen use F10.  FULLVIEW will then
prompt you to prepare your printer and will output the entire
table for you.

     Hitting F2 will provide a screen that shows the current byte
values at each of the hardware ports -- they are shown in real
time.  On very, very rare occasions, reading from a hardware port
will hang the system (I've only found a couple of cards that can
cause trouble, one was an unusual network card, the other a video
card).  If attempting to scroll through the hardware ports locks
the system up, or disrupts the screen colors, you must include a
notation in the FULLVIEW.CFG file telling FULLVIEW not to read
from that port, and instead, return the "??" symbol instead of a
byte value.  If you run in to this problem, I'd appreciate it if
you'd drop me a note telling me the card that caused it.

     Hitting F3 will provide a listing of the current hardware
IRQ (Interrupt Request) addresses -- FULLVIEW ties in to the two
highest priority IRQs, IRQ 0 and IRQ 1.  FULLVIEW will also
indicate if the IRQ is presently enabled.


Return Address:

    This command reports the exact point in conventional memory
(both segment and offset) from which you hotkeyed out of, and to
which you will return, after exiting FULLVIEW.


Prepare PrtScr:

    This command really performs two functions:  1)  It
instantly strips graphics characters from the ascii portion of
memory on the screen to allow for easy text-character viewing and
the easy use of Shft-PrtScr to dump a screen-full of memory to
your printer; and 2)  It "freezes" FULLVIEW from constantly
updating itself so that you may take your time in examining
memory that is otherwise constantly changing.  To return FULLVIEW
to its normal state, simply hit any key (other than Shft-PrtScr,
of course).


Crash to DOS:

    This command allows you to break out of most programs (even
"hung" programs), and it will return an error code (0FFH) to the
parent program that executed the child program (usually DOS
itself).  Simply hit "C" and confirm your wish to crash out.


VII.  OTHER OPERATIONAL COMMANDS

    There are three additional operational commands that are
used less frequently, and thus, are not displayed at the bottom
of FULLVIEW's main screen.  These additional commands are as
follows:

!  -- This command cleans memory by overwriting the word value
      "++" beginning at the first unallocated memory control
      in memory.  Only conventional memory is cleaned; extended
      memory is not cleaned.  If FULLVIEW detects critical
      interrupt routines located within the to-be-cleaned area,
      FULLVIEW will advise you of such and refuse to clean
      memory.  After cleaning memory, exiting FULLVIEW will
      return you to the DOS prompt.  Cleaning memory is handy
      in determining where a program loads its code and how
      much memory the program actually consumed (just clean
      memory right before you execute a program, then hotkey
      into memory and view what has been changed.)

F5 -- This key toggles Liquid Crystal Diode (LCD) mode for
      better performance on laptops and some monochrome monitors.
      LCD mode offers black and white video contrast and a
      larger, easier-to-see cursor.  Occasionally, hotkeying
      out of a program that is continually monitoring screen
      writes will cause a conflict with FULLVIEW's colors,
      if this happens try toggling into LCD mode to override
      the conflict.

F6 -- This key will toggle FULLVIEW's full keyboard interrupt
      control if another program has taken priority over that
      interrupt and is interfering with FULLVIEW's scrolling
      abilities.  Normally, FULLVIEW will have first control
      over the keyboard interrupt.  However, some programs,
      while executing, will take control of this interrupt
      and prevent consistent scrolling while viewing FULLVIEW.
      In such a case, you may toggle FULLVIEW's control to
      restore the consistent scrolling.  Upon exit, FULLVIEW
      will automatically restore the interrupt condition to
      its original placement -- you do not have to remember
      to do it.  If FULLVIEW detects that the conflicting
      program is continually upgrading its keyboard interrupt
      handling (like some versions of SideKick will do),
      FULLVIEW will not upgrade its keyboard priority.



VIII.  IMPLODING CONTROL.

    Actually, an entire (and lengthy) DOC file could be written
on nifty ways to use the Implode Control feature of FULLVIEW to
accomplish an otherwise insurmountable task.  However, I have
always felt that brevity should be enjoined as an outstanding
characteristic of DOC files -- so with that in mind, the
following should suffice:

    "Imploding Control" does just that -- it turns full control
of the system over to FULLVIEW and the user, even if the keyboard
has been shut off, the interrupt vectors altered, and the bios
areas scrambled by the executing program.

    The command key to implement the Implode Control function is
the asterisk ("*") -- this command is not mentioned on the
command list at the bottom of the screen.  When you summon the
Implosion Control feature, you will be asked to input an "Implode
Control Factor" which is the time delay after which FULLVIEW will
take full control of the system, and, of course, turn this
control over to the user.  This time delay may be up to 999
seconds.  After inputting this delay factor, FULLVIEW will ask
whether it should, if you happen to be imploding out of graphics
mode, to attempt to store the video graphics in UNPROTECTED upper
conventional memory -- it really isn't necessary to save the
graphics as they tend to be updated regularly by most programs,
however, the option is there if you wish.  Just realize that
there is always the possibility that the graphics storage might
plaster over some memory that is in use and cause the system to
hang.  If you elect to make the choice to try and save graphics
and, at the moment of implosion, are not in a graphics mode,
FULLVIEW will detect that situation and will not attempt to make
any storage for the non-existent graphics.

    Once you have set the Implosion-Delay, you simply ESC back
to the executing program and allow it to continue to run
normally.  The audible time delay "tick-off" only occurs while
the executing program has control, not while FULLVIEW is in
control -- so there's no rush.  When the time delay factor has
expired, a tone will sound and the execution of that program will
"freeze" in its tracks.  Behind the scenes, FULLVIEW has restored
the necessary areas needed to allow complete access and use of
FULLVIEW back to the same condition as when you selected Implode
Control -- just Control-V into it and you're off. . .  You may
ESC back to the frozen screen at any time to review it and then
Control-V back into FULLVIEW for another round.  When you are
ready for the executing program to continue its operation, just
exit FULLVIEW and touch any key to return control to the
executing program -- it will never know it's been interrupted and
viewed (and maybe changed by you, or copied to a disk file) and
everything will be returned to its state prior to Implosion
(including any keystrokes that were already in the keyboard
buffer prior to Implosion.)


Four quick points on Imploding Control:

    * - You can set an implosion at any time, even from within
another implosion.  Thus, you can continually "chain-set"
implosions and always know full control will be restored in, say,
30 seconds, or 90 seconds, or whatever amount you choose.

    * - All functions of FULLVIEW know that they're in the
middle of an Implosion Control event and will continue to provide
correct information and messages.  (One Example:  After Imploding
Control in the middle of a program that had changed the keyboard
Interrupt 9, you use the "I" function of FULLVIEW to retrieve the
current vector address for Interrupt 9.  FULLVIEW will provide
you with the current interrupt vector address values that it has
placed in that vector so as to provide you control AND the
previous vector address of Interrupt 9 as it existed before
control was imploded.  And, if you elect to change a relevant
interrupt vector (like Int. 21H, the DOS interrupt), FULLVIEW
will ask you if you would like the change to survive the return
from implosion, or if you only want that change to live as long
as FULLVIEW is in control.)  (A Second Example: If you view the
entire interrupt table during an implosion,  FULLVIEW will put an
asterisk next to any interrupt that was different prior to the
implosion.)

    * - When the tone sounds alerting you that FULLVIEW has
taken control, you do not have to access FULLVIEW if you do not
want to.  Simply touch any key other than Control-V and the
program will continue on normally.

    * - FULLVIEW is smart, and it knows the tricks of the trade
(it has even invented a few).  If you're having trouble with a
program, set the Implode Control feature for a bit longer, say,
two minutes.  If there's a way to get you control, and open up
the system for you, FULLVIEW will do it -- and, of course, the
executing program will never know that it's been done.  So
experiment for yourself!


IX.  A WORD ABOUT MODES AND PRIVILEGE.


     If FULLVIEW detects that you are not operating in real mode,
(say by virtue of the DOS program EMM386, or perhaps you're using
a debugger in virtual mode), FULLVIEW will, each time you access
it, confirm its privilege level through system reads.

     Should FULLVIEW detect that the privilege level is
insufficient to allow access beyond the memory allotted memory,
FULLVIEW will sound a tone and display the message:

     Insufficient O/S privilege for extended memory viewing.
                    Attempt to override? (Y/N)

     If you respond with a "No," FULLVIEW will behave as if it
was installed on an 8088 based machine and not allow extended
memory viewing and will wrap-around on memory addresses (a note -
if the A20 Gate is open, FULLVIEW will still allow viewing of the
HMA).   However, if you elect to override, FULLVIEW will continue
to attempt to access all memory (even the portion that the
operating system is denying access to).  If FULLVIEW is
attempting to read a portion of memory that the operating system
(through monitoring of the C.P.U. in protected mode) is
prohibiting, the message "PRIVILEGE ERROR" will appear in the
ascii portion of the screen for that specific area in memory.

     But remember, if you are operating in virtual-86 mode, you
will see FULLVIEW's code twice, once in the conventional memory
area and once in the extended memory area -- BUT IT'S THE SAME
MEMORY!  The capabilities of the 386 processor are re-mapping the
extended memory area to conventional memory addresses.  (In fact,
you're not supposed to be able to see memory areas outside of
what the processor has re-mapped for you, much less change it --
but this is one of the wonders of FULLVIEW).   So experiment for
yourself, and with the knowledge that FULLVIEW will, more often
than not, let you see both where the code that you are viewing
ACTUALLY resides, and where it APPEARS to reside -- and you can
monitor, alter, and work with either, or both, areas along with
the rest of your memory.



X.  CHANGING FULLVIEW'S SETTINGS


    FULLVIEW.CFG is the configuration file for FULLVIEW.  You do
not have to use this file nor does it even have to exist.
However, FULLVIEW will look for it in the default directory when
it installs itself.

    FULLVIEW.CFG is a small text file that may have three
settings in it:  one for changing the hotkey, the next for
excluding ports from being read by FULLVIEW for those rare
systems that have a problem in that area, and the third setting
tells FULLVIEW to install itself already in LCD mode.  These
settings should, for example, appear as follows:


                  hotkey=k
                  port=0123,02A4
                  machine=lcd


    Having these three setting like this would result in the
hotkey being CTRL+K, the ports number 0123 and 02A4 would not be
read by FULLVIEW, and FULLVIEW would install itself already in
LCD mode.  You may exclude up to 14 ports and you may pick any of
the 26 letters as a hotkey.

     You may not specify whether FULLVIEW installs itself as a
color or a monochrome configuration -- you must do this manually,
or if you prefer, include the parameters /C or /M in a batch file
and run it from there.



XI.  TROUBLE SHOOTING FULLVIEW

     Hopefully, you won't have to.  But if you do, there is most
likely an easy way to correct what ever problem you might have.
If worst comes to worst, contact the distributor from whom you
purchased FULLVIEW, and they will help you with any unique
problems that you may have encountered.  Problems with FULLVIEW
are not common, however the following may help if you do run into
one:


Problem -- When I hotkey into a certain application, the screen
goes crazy with gibberish.

Solution -- Some programs will directly alter the video
controller in such a way as to cause a conflict with FULLVIEW's
screen writes.  To overcome this problem, try toggling F5 to put
FULLVIEW into LCD mode (completely black and white), this should
do the trick.


Problem -- When I scroll through the ports, the system either
locks up or the screen colors go bad.

Solution -- One of your ports can not be read from without
causing hardware conflicts.  To remedy this, exclude the
offending port from being read by including the notation
PORT=xxxx (where xxxx is the hexadecimal number of the port) in
the FULLVIEW.CFG file.  Finding the offending port can be a
matter of trial and error, but if the system is hanging, the
highest visible port number is usually the culprit.  For color
problems, the offending port is most likely one of the ports on
your video card -- check the manual that came with the card for
the addresses and try excluding some of those port addresses.


Problem -- While running under DesqView, FULLVIEW's colors don't
look right and the keyboard locks up.

Solution -- Under a multi-tasking environment such as DesqView,
you should try configuring the operating system to avoid keyboard
conflicts, allow FULLVIEW to use its own colors, and to avoid
sharing of the CPU while operating in the foreground.  If you
continue to have problems under a multi-tasking environment,
please contact your distributor.



XII.  SOME FINAL THOUGHTS AND OTHER THINGS. . .

"LOAD ME HIGH"

    DOS 5.0, and some other operating systems, allow some TSRs
and device drivers to be loaded high, meaning above the one
megabyte DOS boundary, but still be available to DOS by remapping
the program to unused address spaces (usually around absolute
address C0000 to F0000 in conventional memory).  If FULLVIEW is
loaded high, you will be able to find it in memory in two places:
1)  The "re-mapped" location in conventional memory; and 2) The
"true" location in extended memory.  Scrolling through the
extended memory location that is occupied by FULLVIEW will give
the user an appreciation for the power that FULLVIEW's coding
possesses and its ability to constantly update itself -- even
while in extended memory and utilizing a protected mode
environment.  The easiest way to find FULLVIEW is to search for
the string "F U L L V I E W" (which occurs a couple of times).


"EXTENDED MEMORY'S TRUE USE"

    If you are making use of your extended memory by using disk-
cache software, FULLVIEW will let you see the sectors that your
software is storing.  The same is true for any program that
utilizes extended memory.

"LOST DATA"

    Ever hung your computer with important, yet unsaved, data
still in RAM?  FULLVIEW might still be able to save it -- even if
it wasn't in memory to begin with!  Of course, if FULLVIEW was in
memory, just hotkey into FULLVIEW, search for a string in the
document, and then write that portion to disk.  You might have to
do a little editing, but probably not as much as you think.  If
FULLVIEW was not in memory, simply put a system disk in the "A"
drive and perform a warm re-boot, then load FULLVIEW and perform
a search for the "lost" document -- the RAM that was holding the
information might have kept it alive during the warm re-boot and,
of course, FULLVIEW can find it and save it for you when
everything else you have swears it's not there at all.


"CHANGING MEMORY"

    Your CPU is doing something all the time -- even when it's
just sitting there waiting for a keystroke.  And FULLVIEW will
let you watch it -- as it changes!  Try using the "J" command to
jump to 0000:0400 in conventional memory.  You will see at least
two, and occasionally three, bytes continually change -- other
parts of memory can be changing also, just use FULLVIEW to watch
them.  And, as mentioned above, you can even observe FULLVIEW
observing and altering itself since portions of FULLVIEW are
always changing (flying, really).  Of course, to "freeze" the
picture (and dump it to the printer, if you'd like) simply touch
"P".  If you wondered what the changing byte at 0000:0440 was,
it's the Motor Control Time-Out Counter, and the other two were
the clock.


"ENCRYPTED PROGRAMS"

Ever get annoyed with a program that only decrypts or
decompresses itself in memory -- so that you can't figure out
what it's doing until it's already done it?  You've probably
already figured out that FULLVIEW is the answer -- just hotkey
into the program after it has decrypted in memory and then write
it to disk in its unencrypted form.  If the program had the
audacity to shut off the keyboard and lock up the BIOS areas
before it decrypts, just use the Implode Control abilities of
FULLVIEW to bust it open anyway.


"WHAT DO I REALLY HAVE?"

    A pet-peeve of mine is the "System Identification and
Information Programs" that tell you everything you have loaded
into memory and how much memory you have.  Not that they're
useless, just that different programs continue to tell me that I
have different things (like an extra 48k of memory at E000:0000
when I know that I don't).  Actually, I know what the problem is
-- it's a little add-on cache board that uses super-fast memory
chips.  But only FULLVIEW will let me look at my memory and then
try to write to it --  the best way in the world to tell if it's
live RAM or just funny-looking ROM, or nothing at all! And for
the software engineer. . . how did that TSR (or some other rogue
program) load itself in memory so that it became "invisible" to
DOS and utility programs?  (But not, of course, to FULLVIEW,
which will find it, view it, change it, and even write it back to
disk for you).  And now, with DOS 5.0's ability to use "empty"
address areas, it becomes even more important to be able to
accurately view your memory.


"WHAT'S REALLY IN THAT PROGRAM?"

    Everybody has wondered "What makes that program tick?" and
"What's really in that program to see?".  Of course, FULLVIEW is
the answer -- it's a tool that can be used to do almost
anything,from viewing programs, to changing them, to actually
creating them.  FULLVIEW's potential is unlimited.  And what's
more, whatever your favorite software tool is, FULLVIEW will work
right along with it, and complement it, to make your job easier,
quicker, and more productive.



XI.  CONCLUSION.

     Thank you for licensing my FULLVIEW utility.  If you have
any thoughts on how FULLVIEW can be improved, or if you have
questions of a technical nature, please drop a note to the
distributor, or you can send me an E-Mail message directly.  My
Internet address is [e-mail] -- I'll look forward
to hearing from you.




                               Patrick A. Toulme
                               January, 1992


PTOULME@GMUVAX         (Bitnet)
[e-mail] (Internet)